package com.bytezero.stringclass;

import org.junit.Test;

import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;
import java.sql.SQLOutput;
import java.util.Arrays;
import java.util.Locale;

/**
 *
 *              String 常用方法(1)
 * int Length():  返回字符串的长度： return value.length
 * char charAt(int index):返回某索引处的字符 return value[index]
 * boolean isEmpty(): 判断是否是空字符串： return value.length == 0;
 * String toLowerCase(): 使用默认语言环境，将String中的所有字符转换为小写
 * String toUpperCase(): 使用默认语言环境，将String中的所有字符转换为大写
 * String trim(): 返回字符串的副本，忽略前导空白和尾部空白
 * boolean equals(Object obj ):比较字符串的内容是否相同
 *
 * boolean equalsUIgnoreCase(String anotherString):与equals 方法类似，忽略大小写
 * String concat(String str):将指定字符串连接到此字符串的结尾。 等价于 “+”
 * int compareTo(String anotherString):比较两个字符串的大小
 * String substring(int beginIndex):返回一个新的字符串，它是此字符串的从beginIndex开始截取
 *      到最后的一个字符串
 * String substring(int beginIndex,int endIndex):返回一个新字符串，它是此字符串从beginIndex开始
 * 截取到endIndex(不含)的一个字符串
 *
 *
 *
 *
 * @author Bytezero1·zhenglei!    Email:420498246@qq.com
 * create  2021-10-22 8:08
 */
public class StringMethodTest {

    /*
      涉及到String类与其他结构之间的转换

     */

       //String  与 基本数据类型，包装类之间的转换
       //String --->基本数据类型，包装类：调用包装类的静态方法：parseXxx(str)
       //基本数据类型，包装类 -->String :调用String重载的valuOf(xxx)

      @Test
      public void  test5(){
          String str1 = "132";
//          int num = (int)str1;    //错误的
          //String --->基本数据类型，包装类：调用包装类的静态方法：parseXxx(str)
          int num = Integer.parseInt(str1);

          //基本数据类型，包装类 -->String :调用String重载的valuOf(xxx)
          String str2 = String.valueOf(num);

          String str3 = num +"";   //堆里
          System.out.println(str1 == str3);  //false

      }


      /*
      String 与 char[]之间的转换

      String----> char[]:调用String的toCharArray()
      char[] ---->String:调用String的构造器
       */
    @Test
    public void test6(){
        String str1 = "abc123";

        char[] charArray = str1.toCharArray();
        for(int i =0;i <charArray.length;i++){
            System.out.println(charArray[i]);  //a  b   c  1  2 3
        }

        char[] arr = new char[]{'h','e','l','l','o'};
        String str2 = new String(arr);
        System.out.println(str2);  //hello

    }


    /**
     *
     *  String 与 byte[]之间的转换
     *  编码：String ---> byte[]:调用String的getBytes()
     *  解码：byte[]--->String: 调用String的构造器
     *
     *
     *  编码： 字符串--->字节（看得懂--->看不懂二进制数据）
     *  解码： 编码的逆过程，字节-->字符串 （看不懂二进制数据--->看得懂）
     *
     *  说明：解码时，要求解码使用时的字符集必须与编码时使用的字符集一致，否则会出现乱码
     *
     */
    @Test
    public  void test7() throws UnsupportedEncodingException {
        String str1 = "abc123";
        byte[] bytes = str1.getBytes();
        System.out.println(Arrays.toString(bytes));  //[97, 98, 99, 49, 50, 51]

       String str2 = "abc123中国";
       byte[] bytes1 = str2.getBytes(); //使用默认的字符集，进行编码
       System.out.println(Arrays.toString(bytes1));//[97, 98, 99, 49, 50, 51, -28, -72, -83, -27, -101, -67]

        byte[] gbks = str2.getBytes("gbk"); //使用 gbk字符集进行编码
        System.out.println(Arrays.toString(gbks)); //[97, 98, 99, 49, 50, 51, -42, -48, -71, -6]

        System.out.println("*********************");
        String str3 = new String(bytes1);//使用默认的字符集，进行解码
        System.out.println(str3);  //abc123中国

        String str4 = new String(gbks);
        System.out.println(str4);  //abc123�й� 乱码 原因：编码集与解码集不一致

        String str5 = new String(gbks, "gbk");
        System.out.println(str5);  //abc123中国

    }









    @Test
    public void test2(){
        String s1 = "HelloWorld";
        String s2 = "helloworld";
        System.out.println(s1.equals(s2));//false
        System.out.println(s1.equalsIgnoreCase(s2)); //true 忽略大小写

        String s3 = "abc";
        String s4 = s3.concat("def");
        System.out.println(s4);   //abcdef

        String s5 = "abc";
        String s6 = new String("abe");
        System.out.println(s5.compareTo(s6)); // -2 涉及到字符串的排序

       String s7 = "上海东方明珠";
        String s8 = s7.substring(2);
        System.out.println(s7);   //上海东方明珠
        System.out.println(s8);   //东方明珠

        String s9 = s7.substring(2, 4);
        System.out.println(s9);   //东方


    }


    @Test
    public void test1(){
        String s1 = "HelloWorld";
        System.out.println(s1.length()); //10
        System.out.println(s1.charAt(0));//h
        System.out.println(s1.charAt(9));//d

       // System.out.println(s1.charAt(10));//异常： StringIndexOutOfBoundsException

        System.out.println(s1.isEmpty());//false
//        s1 = "";
//        System.out.println(s1.isEmpty());//true

        String s2 = s1.toLowerCase();
        System.out.println(s1); //HelloWorld  不可变性，仍然为原来的字符串
        System.out.println(s2); //helloworld  改为小写的

        String s3 = s1.toUpperCase();
        System.out.println(s1); //HelloWorld  不可变性，仍然为原来的字符串
        System.out.println(s3);//HELLOWORLD 改为大写

        String  s4 = "   he  ll o world   ";
        String s5 = s4.trim();
        System.out.println("------"+s4+"-------"); //------   he  ll o world   -------
        System.out.println("------"+s5+"-------"); //------he  ll o world-------




    }

    /**
     *                String 常用方法（2）
     *  boolean endsWith(String suffix):测试此字符串是否以指定的后缀结束
     *  boolean startsWith(String prefix): 测试此字符串是否以指定的前缀开始
     *  boolean startsDWith(String prefix,int toffset):测试此字符串从指定索引开始的
     *  字符串是否以指定前缀开始
     *
     *  boolean contains(CharSequence s):当且仅当此字符串包含指定的char值序列时，返回true
     *  int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引
     *  int indexOf(String str,int fromIndex):返回指定子字符串在此字符串中第一次出现处的索引，
     *  从指定的索引开始
     *  int lastIndexOf(String str):返回指定子符串在此字符串中最右边出现处的索引
     *  int lastIndexOf(String str,int fromIndex):返回指定子字符串在此字符串中最后
     *  一次出现处的索引，从指定的索引开始反向搜索
     *
     *  注：indexOf和lastIndexOf方法如果未找到都是返回-1
     *
     *
     *
     *
     *
     *  @author Bytezero1·zhenglei!    Email:420498246@qq.com
     *   create  2021-10-22 8:08
     *
     */

      @Test
    public void test3(){
          String str1 = "helloworld";
          boolean b1 = str1.endsWith("ld");
          System.out.println(b1);   //true

          boolean b2 = str1.startsWith("H");
          System.out.println(b2);  //false

          boolean b3 = str1.startsWith("ll",2);
          System.out.println(b3);  //true


          String str2 = "wo";
          System.out.println(str1.contains(str2));  //true


          System.out.println(str1.indexOf("lo"));  //3
          System.out.println(str1.indexOf("lol"));  //-1

          System.out.println(str1.indexOf("lo",5)); //-1

          String str3 = "hellorworld";
          System.out.println(str3.lastIndexOf("or")); //7
          System.out.println(str3.lastIndexOf("or",6)); //4

           //什么情况下，indexOf(str)和lastIndexOf(str)返回值相同
           //情况一：存在一个唯一的str     情况二：不存在str





      }


    /**
     *             String常用方法3
     *   替换：
     *  String replace(char oldChar,char newChar): 返回一个新的字符串，它是通过
     *  用newChar替换此字符串中出现的所有oldChar得到的
     *  String replace(CharSequence target,CharSequence replacement):使用指定的
     *  字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串
     *  String replaceAll(String regex,String replacement):使用给定的 replacement
     *  替换此字符串所有匹配给定的正则表达式的子字符串
     *  String replaceFirst(String regex,String replacement):使用给定的replacement
     *  替换此字符串匹配给定的正则表达式的第一个字符串
     *
     *  匹配：
     *  boolean matches(String regex):告知此字符串是否匹配给定的正则表达式
     *
     *  切片：
     *  String[] split(String regex):根据给定正则表达式的匹配拆分此字符串
     *  String[] sqlit(String regex,int limit):根据匹配给定的正则表达式来拆分
     *  此字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中
     *
     *
     *
     *
     *   @author Bytezero1·zhenglei!    Email:420498246@qq.com
     *   create  2021-10-22 8:08
     */

    @Test
    public void test4(){

        String str1 = "上上海东方明珠塔上海";
        String str2 = str1.replace('上', '北');

        System.out.println(str1);  //上上海东方明珠塔上海
        System.out.println(str2);  //北北海东方明珠塔北海

        String str3 = str1.replace("上海", "北京");
        System.out.println(str3); //上北京东方明珠塔北京


    }



















}
